Added host-side API tracing support

Change-Id: Id473243344d76e58e326c5a1cb487c57cf5c736c
Signed-off-by: Anton V Gorshkov <anton.v.gorshkov@intel.com>

unit_tests/api/CMakeLists.txt

@@ -92,6 +92,7 @@ set(IGDRCL_SRCS_tests_api
   ${CMAKE_CURRENT_SOURCE_DIR}/cl_get_supported_image_formats_tests.inl
   ${CMAKE_CURRENT_SOURCE_DIR}/cl_icd_get_platform_ids_khr_tests.inl
   ${CMAKE_CURRENT_SOURCE_DIR}/cl_intel_accelerator_tests.inl
+  ${CMAKE_CURRENT_SOURCE_DIR}/cl_intel_tracing_tests.inl
   ${CMAKE_CURRENT_SOURCE_DIR}/cl_intel_motion_estimation.cpp
   ${CMAKE_CURRENT_SOURCE_DIR}/cl_link_program_tests.inl
   ${CMAKE_CURRENT_SOURCE_DIR}/cl_mem_locally_uncached_resource_tests.cpp

unit_tests/api/api_tests_wrapper3.cpp

@@ -1,5 +1,5 @@
 /*
- * Copyright (C) 2018 Intel Corporation
+ * Copyright (C) 2018-2019 Intel Corporation
  *
  * SPDX-License-Identifier: MIT
  *
@@ -15,6 +15,7 @@
 #include "unit_tests/api/cl_get_supported_image_formats_tests.inl"
 #include "unit_tests/api/cl_icd_get_platform_ids_khr_tests.inl"
 #include "unit_tests/api/cl_intel_accelerator_tests.inl"
+#include "unit_tests/api/cl_intel_tracing_tests.inl"
 #include "unit_tests/api/cl_link_program_tests.inl"
 #include "unit_tests/api/cl_release_command_queue_tests.inl"
 #include "unit_tests/api/cl_release_context_tests.inl"

unit_tests/api/cl_api_tests.h

@@ -7,6 +7,7 @@
 
 #pragma once
 #include "runtime/api/api.h"
+#include "runtime/tracing/tracing_api.h"
 #include "test.h"
 #include "unit_tests/fixtures/platform_fixture.h"
 

unit_tests/api/cl_get_extension_function_address_for_platform_tests.inl

@@ -47,4 +47,34 @@ TEST_F(clGetExtensionFunctionAddressForPlatformTests, GivenClCreateProgramWithIL
     auto retVal = clGetExtensionFunctionAddressForPlatform(pPlatform, "clCreateProgramWithILKHR");
     EXPECT_EQ(retVal, reinterpret_cast<void *>(clCreateProgramWithILKHR));
 }
+
+TEST_F(clGetExtensionFunctionAddressForPlatformTests, GivenClCreateTracingHandleINTELWhenGettingExtensionFunctionThenCorrectAddressIsReturned) {
+    auto retVal = clGetExtensionFunctionAddressForPlatform(pPlatform, "clCreateTracingHandleINTEL");
+    EXPECT_EQ(retVal, reinterpret_cast<void *>(clCreateTracingHandleINTEL));
+}
+
+TEST_F(clGetExtensionFunctionAddressForPlatformTests, GivenClSetTracingPointINTELWhenGettingExtensionFunctionThenCorrectAddressIsReturned) {
+    auto retVal = clGetExtensionFunctionAddressForPlatform(pPlatform, "clSetTracingPointINTEL");
+    EXPECT_EQ(retVal, reinterpret_cast<void *>(clSetTracingPointINTEL));
+}
+
+TEST_F(clGetExtensionFunctionAddressForPlatformTests, GivenClDestroyTracingHandleINTELWhenGettingExtensionFunctionThenCorrectAddressIsReturned) {
+    auto retVal = clGetExtensionFunctionAddressForPlatform(pPlatform, "clDestroyTracingHandleINTEL");
+    EXPECT_EQ(retVal, reinterpret_cast<void *>(clDestroyTracingHandleINTEL));
+}
+
+TEST_F(clGetExtensionFunctionAddressForPlatformTests, GivenClEnableTracingINTELWhenGettingExtensionFunctionThenCorrectAddressIsReturned) {
+    auto retVal = clGetExtensionFunctionAddressForPlatform(pPlatform, "clEnableTracingINTEL");
+    EXPECT_EQ(retVal, reinterpret_cast<void *>(clEnableTracingINTEL));
+}
+
+TEST_F(clGetExtensionFunctionAddressForPlatformTests, GivenClDisableTracingINTELLWhenGettingExtensionFunctionThenCorrectAddressIsReturned) {
+    auto retVal = clGetExtensionFunctionAddressForPlatform(pPlatform, "clDisableTracingINTEL");
+    EXPECT_EQ(retVal, reinterpret_cast<void *>(clDisableTracingINTEL));
+}
+
+TEST_F(clGetExtensionFunctionAddressForPlatformTests, GivenClGetTracingStateINTELWhenGettingExtensionFunctionThenCorrectAddressIsReturned) {
+    auto retVal = clGetExtensionFunctionAddressForPlatform(pPlatform, "clGetTracingStateINTEL");
+    EXPECT_EQ(retVal, reinterpret_cast<void *>(clGetTracingStateINTEL));
+}
 } // namespace ULT

unit_tests/api/cl_get_extension_function_address_tests.inl

@@ -63,4 +63,33 @@ TEST_F(clGetExtensionFunctionAddressTests, givenClAddCommentToAubIntelAsInputWhe
     EXPECT_EQ(functionPointer, reinterpret_cast<void *>(clAddCommentINTEL));
 }
 
+TEST_F(clGetExtensionFunctionAddressTests, GivenClCreateTracingHandleINTELWhenGettingExtensionFunctionThenCorrectAddressIsReturned) {
+    auto retVal = clGetExtensionFunctionAddress("clCreateTracingHandleINTEL");
+    EXPECT_EQ(retVal, reinterpret_cast<void *>(clCreateTracingHandleINTEL));
+}
+
+TEST_F(clGetExtensionFunctionAddressTests, GivenClSetTracingPointINTELWhenGettingExtensionFunctionThenCorrectAddressIsReturned) {
+    auto retVal = clGetExtensionFunctionAddress("clSetTracingPointINTEL");
+    EXPECT_EQ(retVal, reinterpret_cast<void *>(clSetTracingPointINTEL));
+}
+
+TEST_F(clGetExtensionFunctionAddressTests, GivenClDestroyTracingHandleINTELWhenGettingExtensionFunctionThenCorrectAddressIsReturned) {
+    auto retVal = clGetExtensionFunctionAddress("clDestroyTracingHandleINTEL");
+    EXPECT_EQ(retVal, reinterpret_cast<void *>(clDestroyTracingHandleINTEL));
+}
+
+TEST_F(clGetExtensionFunctionAddressTests, GivenClEnableTracingINTELWhenGettingExtensionFunctionThenCorrectAddressIsReturned) {
+    auto retVal = clGetExtensionFunctionAddress("clEnableTracingINTEL");
+    EXPECT_EQ(retVal, reinterpret_cast<void *>(clEnableTracingINTEL));
+}
+
+TEST_F(clGetExtensionFunctionAddressTests, GivenClDisableTracingINTELLWhenGettingExtensionFunctionThenCorrectAddressIsReturned) {
+    auto retVal = clGetExtensionFunctionAddress("clDisableTracingINTEL");
+    EXPECT_EQ(retVal, reinterpret_cast<void *>(clDisableTracingINTEL));
+}
+
+TEST_F(clGetExtensionFunctionAddressTests, GivenClGetTracingStateINTELWhenGettingExtensionFunctionThenCorrectAddressIsReturned) {
+    auto retVal = clGetExtensionFunctionAddress("clGetTracingStateINTEL");
+    EXPECT_EQ(retVal, reinterpret_cast<void *>(clGetTracingStateINTEL));
+}
 } // namespace ULT

unit_tests/api/cl_intel_tracing_tests.inl

@@ -0,0 +1,867 @@
+/*
+ * Copyright (C) 2019 Intel Corporation
+ *
+ * SPDX-License-Identifier: MIT
+ *
+ */
+
+#include "runtime/tracing/tracing_api.h"
+#include "runtime/tracing/tracing_notify.h"
+#include "unit_tests/api/cl_api_tests.h"
+
+using namespace NEO;
+
+namespace ULT {
+
+struct IntelTracingTest : public api_tests {
+  public:
+    IntelTracingTest() {}
+
+    void SetUp() override {
+        api_tests::SetUp();
+    }
+
+    void TearDown() override {
+        api_tests::TearDown();
+    }
+
+  protected:
+    static void callback(cl_function_id fid, cl_callback_data *callbackData, void *userData) {
+        ASSERT_NE(nullptr, userData);
+        IntelTracingTest *base = (IntelTracingTest *)userData;
+        base->vcallback(fid, callbackData, nullptr);
+    }
+
+    virtual void vcallback(cl_function_id fid, cl_callback_data *callbackData, void *userData) {}
+
+  protected:
+    cl_tracing_handle handle = nullptr;
+    cl_int status = CL_SUCCESS;
+};
+
+TEST_F(IntelTracingTest, GivenInvalidDeviceExpectFail) {
+    status = clCreateTracingHandleINTEL(nullptr, callback, nullptr, &handle);
+    EXPECT_EQ(static_cast<cl_tracing_handle>(nullptr), handle);
+    EXPECT_EQ(CL_INVALID_VALUE, status);
+}
+
+TEST_F(IntelTracingTest, GivenInvalidCallbackExpectFail) {
+    status = clCreateTracingHandleINTEL(devices[0], nullptr, nullptr, &handle);
+    EXPECT_EQ(static_cast<cl_tracing_handle>(nullptr), handle);
+    EXPECT_EQ(CL_INVALID_VALUE, status);
+}
+
+TEST_F(IntelTracingTest, GivenInvalidHandlePointerExpectFail) {
+    status = clCreateTracingHandleINTEL(devices[0], callback, nullptr, nullptr);
+    EXPECT_EQ(CL_INVALID_VALUE, status);
+}
+
+TEST_F(IntelTracingTest, GivenInvalidHandleExpectFail) {
+    status = clSetTracingPointINTEL(nullptr, CL_FUNCTION_clBuildProgram, CL_TRUE);
+    EXPECT_EQ(CL_INVALID_VALUE, status);
+
+    status = clDestroyTracingHandleINTEL(nullptr);
+    EXPECT_EQ(CL_INVALID_VALUE, status);
+
+    status = clEnableTracingINTEL(nullptr);
+    EXPECT_EQ(CL_INVALID_VALUE, status);
+
+    status = clDisableTracingINTEL(nullptr);
+    EXPECT_EQ(CL_INVALID_VALUE, status);
+
+    status = clSetTracingPointINTEL(nullptr, CL_FUNCTION_clBuildProgram, CL_FALSE);
+    EXPECT_EQ(CL_INVALID_VALUE, status);
+
+    cl_bool enabled = CL_FALSE;
+    status = clGetTracingStateINTEL(nullptr, &enabled);
+    EXPECT_EQ(CL_INVALID_VALUE, status);
+}
+
+TEST_F(IntelTracingTest, GivenInactiveHandleExpectFail) {
+    status = clCreateTracingHandleINTEL(devices[0], callback, nullptr, &handle);
+    EXPECT_EQ(CL_SUCCESS, status);
+
+    status = clDisableTracingINTEL(handle);
+    EXPECT_EQ(CL_INVALID_VALUE, status);
+
+    status = clDestroyTracingHandleINTEL(handle);
+    EXPECT_EQ(CL_SUCCESS, status);
+}
+
+TEST_F(IntelTracingTest, GivenTooManyHandlesExpectFail) {
+    cl_tracing_handle handle[HostSideTracing::TRACING_MAX_HANDLE_COUNT + 1] = {nullptr};
+
+    for (uint32_t i = 0; i < HostSideTracing::TRACING_MAX_HANDLE_COUNT + 1; ++i) {
+        status = clCreateTracingHandleINTEL(devices[0], callback, nullptr, &(handle[i]));
+        EXPECT_EQ(CL_SUCCESS, status);
+    }
+
+    for (uint32_t i = 0; i < HostSideTracing::TRACING_MAX_HANDLE_COUNT; ++i) {
+        status = clEnableTracingINTEL(handle[i]);
+        EXPECT_EQ(CL_SUCCESS, status);
+    }
+
+    status = clEnableTracingINTEL(handle[HostSideTracing::TRACING_MAX_HANDLE_COUNT]);
+    EXPECT_EQ(CL_OUT_OF_RESOURCES, status);
+
+    for (uint32_t i = 0; i < HostSideTracing::TRACING_MAX_HANDLE_COUNT; ++i) {
+        status = clDisableTracingINTEL(handle[i]);
+        EXPECT_EQ(CL_SUCCESS, status);
+    }
+
+    for (uint32_t i = 0; i < HostSideTracing::TRACING_MAX_HANDLE_COUNT + 1; ++i) {
+        status = clDestroyTracingHandleINTEL(handle[i]);
+        EXPECT_EQ(CL_SUCCESS, status);
+    }
+}
+
+TEST_F(IntelTracingTest, EnableTracingExpectPass) {
+    status = clCreateTracingHandleINTEL(devices[0], callback, this, &handle);
+    EXPECT_EQ(CL_SUCCESS, status);
+
+    status = clSetTracingPointINTEL(handle, CL_FUNCTION_clBuildProgram, CL_TRUE);
+    EXPECT_EQ(CL_SUCCESS, status);
+
+    cl_bool enabled = CL_FALSE;
+    status = clGetTracingStateINTEL(handle, &enabled);
+    EXPECT_EQ(CL_SUCCESS, status);
+    EXPECT_EQ(static_cast<cl_bool>(CL_FALSE), enabled);
+
+    status = clEnableTracingINTEL(handle);
+    EXPECT_EQ(CL_SUCCESS, status);
+
+    status = clGetTracingStateINTEL(handle, &enabled);
+    EXPECT_EQ(CL_SUCCESS, status);
+    EXPECT_EQ(static_cast<cl_bool>(CL_TRUE), enabled);
+
+    status = clDisableTracingINTEL(handle);
+    EXPECT_EQ(CL_SUCCESS, status);
+
+    status = clGetTracingStateINTEL(handle, &enabled);
+    EXPECT_EQ(CL_SUCCESS, status);
+    EXPECT_EQ(static_cast<cl_bool>(CL_FALSE), enabled);
+
+    status = clSetTracingPointINTEL(handle, CL_FUNCTION_clBuildProgram, CL_FALSE);
+    EXPECT_EQ(CL_SUCCESS, status);
+
+    status = clDestroyTracingHandleINTEL(handle);
+    EXPECT_EQ(CL_SUCCESS, status);
+}
+
+TEST_F(IntelTracingTest, EnableTwoHandlesExpectPass) {
+    cl_tracing_handle handle1 = nullptr;
+    status = clCreateTracingHandleINTEL(devices[0], callback, this, &handle1);
+    EXPECT_EQ(CL_SUCCESS, status);
+    cl_tracing_handle handle2 = nullptr;
+    status = clCreateTracingHandleINTEL(devices[0], callback, this, &handle2);
+    EXPECT_EQ(CL_SUCCESS, status);
+
+    status = clSetTracingPointINTEL(handle1, CL_FUNCTION_clBuildProgram, CL_TRUE);
+    EXPECT_EQ(CL_SUCCESS, status);
+    status = clSetTracingPointINTEL(handle2, CL_FUNCTION_clBuildProgram, CL_TRUE);
+    EXPECT_EQ(CL_SUCCESS, status);
+
+    status = clEnableTracingINTEL(handle1);
+    EXPECT_EQ(CL_SUCCESS, status);
+    status = clEnableTracingINTEL(handle2);
+    EXPECT_EQ(CL_SUCCESS, status);
+
+    cl_bool enabled = CL_FALSE;
+    status = clGetTracingStateINTEL(handle1, &enabled);
+    EXPECT_EQ(CL_SUCCESS, status);
+    EXPECT_EQ(static_cast<cl_bool>(CL_TRUE), enabled);
+    status = clGetTracingStateINTEL(handle2, &enabled);
+    EXPECT_EQ(CL_SUCCESS, status);
+    EXPECT_EQ(static_cast<cl_bool>(CL_TRUE), enabled);
+
+    status = clDisableTracingINTEL(handle1);
+    EXPECT_EQ(CL_SUCCESS, status);
+    status = clDisableTracingINTEL(handle2);
+    EXPECT_EQ(CL_SUCCESS, status);
+
+    status = clDestroyTracingHandleINTEL(handle1);
+    EXPECT_EQ(CL_SUCCESS, status);
+    status = clDestroyTracingHandleINTEL(handle2);
+    EXPECT_EQ(CL_SUCCESS, status);
+}
+
+struct IntelAllTracingTest : public IntelTracingTest {
+  public:
+    IntelAllTracingTest() {}
+
+    void SetUp() override {
+        IntelTracingTest::SetUp();
+
+        status = clCreateTracingHandleINTEL(devices[0], callback, this, &handle);
+        ASSERT_NE(nullptr, handle);
+        ASSERT_EQ(CL_SUCCESS, status);
+
+        for (uint32_t i = 0; i < CL_FUNCTION_COUNT; ++i) {
+            status = clSetTracingPointINTEL(handle, static_cast<cl_function_id>(i), CL_TRUE);
+            ASSERT_EQ(CL_SUCCESS, status);
+        }
+
+        status = clEnableTracingINTEL(handle);
+        ASSERT_EQ(CL_SUCCESS, status);
+    }
+
+    void TearDown() override {
+        status = clDisableTracingINTEL(handle);
+        ASSERT_EQ(CL_SUCCESS, status);
+
+        status = clDestroyTracingHandleINTEL(handle);
+        ASSERT_EQ(CL_SUCCESS, status);
+
+        IntelTracingTest::TearDown();
+    }
+
+  protected:
+    void vcallback(cl_function_id fid, cl_callback_data *callbackData, void *userData) override {
+        if (fid == functionId) {
+            if (callbackData->site == CL_CALLBACK_SITE_ENTER) {
+                ++enterCount;
+            } else if (callbackData->site == CL_CALLBACK_SITE_EXIT) {
+                ++exitCount;
+            }
+        }
+    }
+
+    uint16_t callFunctions() {
+        uint16_t count = 0;
+
+        ++count;
+        functionId = CL_FUNCTION_clBuildProgram;
+        clBuildProgram(0, 0, 0, 0, 0, 0);
+
+        ++count;
+        functionId = CL_FUNCTION_clCloneKernel;
+        clCloneKernel(0, 0);
+
+        ++count;
+        functionId = CL_FUNCTION_clCompileProgram;
+        clCompileProgram(0, 0, 0, 0, 0, 0, 0, 0, 0);
+
+        ++count;
+        functionId = CL_FUNCTION_clCreateBuffer;
+        clCreateBuffer(0, 0, 0, 0, 0);
+
+        ++count;
+        functionId = CL_FUNCTION_clCreateCommandQueue;
+        clCreateCommandQueue(0, 0, 0, 0);
+
+        ++count;
+        functionId = CL_FUNCTION_clCreateCommandQueueWithProperties;
+        clCreateCommandQueueWithProperties(0, 0, 0, 0);
+
+        ++count;
+        functionId = CL_FUNCTION_clCreateContext;
+        clCreateContext(0, 0, 0, 0, 0, 0);
+
+        ++count;
+        functionId = CL_FUNCTION_clCreateContextFromType;
+        clCreateContextFromType(0, 0, 0, 0, 0);
+
+        ++count;
+        cl_image_desc imageDesc = {0};
+        functionId = CL_FUNCTION_clCreateImage;
+        clCreateImage(0, 0, 0, &imageDesc, 0, 0);
+
+        ++count;
+        functionId = CL_FUNCTION_clCreateImage2D;
+        clCreateImage2D(0, 0, 0, 0, 0, 0, 0, 0);
+
+        ++count;
+        functionId = CL_FUNCTION_clCreateImage3D;
+        clCreateImage3D(0, 0, 0, 0, 0, 0, 0, 0, 0, 0);
+
+        ++count;
+        functionId = CL_FUNCTION_clCreateKernel;
+        clCreateKernel(0, 0, 0);
+
+        ++count;
+        functionId = CL_FUNCTION_clCreateKernelsInProgram;
+        clCreateKernelsInProgram(0, 0, 0, 0);
+
+        ++count;
+        functionId = CL_FUNCTION_clCreatePipe;
+        clCreatePipe(0, 0, 0, 0, 0, 0);
+
+        ++count;
+        functionId = CL_FUNCTION_clCreateProgramWithBinary;
+        const size_t length = 32;
+        unsigned char binary[length] = {0};
+        clCreateProgramWithBinary(0, 0, &(devices[0]), &length, reinterpret_cast<const unsigned char **>(&binary), 0, 0);
+
+        ++count;
+        functionId = CL_FUNCTION_clCreateProgramWithBuiltInKernels;
+        clCreateProgramWithBuiltInKernels(0, 0, 0, 0, 0);
+
+        ++count;
+        functionId = CL_FUNCTION_clCreateProgramWithIL;
+        clCreateProgramWithIL(0, 0, 0, 0);
+
+        ++count;
+        functionId = CL_FUNCTION_clCreateProgramWithSource;
+        clCreateProgramWithSource(0, 0, 0, 0, 0);
+
+        ++count;
+        functionId = CL_FUNCTION_clCreateSampler;
+        clCreateSampler(0, 0, 0, 0, 0);
+
+        ++count;
+        functionId = CL_FUNCTION_clCreateSamplerWithProperties;
+        clCreateSamplerWithProperties(0, 0, 0);
+
+        ++count;
+        functionId = CL_FUNCTION_clCreateSubBuffer;
+        clCreateSubBuffer(0, 0, 0, 0, 0);
+
+        ++count;
+        functionId = CL_FUNCTION_clCreateSubDevices;
+        clCreateSubDevices(0, 0, 0, 0, 0);
+
+        ++count;
+        functionId = CL_FUNCTION_clCreateUserEvent;
+        clCreateUserEvent(0, 0);
+
+        ++count;
+        functionId = CL_FUNCTION_clEnqueueBarrier;
+        clEnqueueBarrier(0);
+
+        ++count;
+        functionId = CL_FUNCTION_clEnqueueBarrierWithWaitList;
+        clEnqueueBarrierWithWaitList(0, 0, 0, 0);
+
+        ++count;
+        functionId = CL_FUNCTION_clEnqueueCopyBuffer;
+        clEnqueueCopyBuffer(0, 0, 0, 0, 0, 0, 0, 0, 0);
+
+        ++count;
+        functionId = CL_FUNCTION_clEnqueueCopyBufferRect;
+        clEnqueueCopyBufferRect(0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0);
+
+        ++count;
+        functionId = CL_FUNCTION_clEnqueueCopyBufferToImage;
+        clEnqueueCopyBufferToImage(0, 0, 0, 0, 0, 0, 0, 0, 0);
+
+        ++count;
+        functionId = CL_FUNCTION_clEnqueueCopyImage;
+        clEnqueueCopyImage(0, 0, 0, 0, 0, 0, 0, 0, 0);
+
+        ++count;
+        functionId = CL_FUNCTION_clEnqueueCopyImageToBuffer;
+        clEnqueueCopyImageToBuffer(0, 0, 0, 0, 0, 0, 0, 0, 0);
+
+        ++count;
+        functionId = CL_FUNCTION_clEnqueueFillBuffer;
+        clEnqueueFillBuffer(0, 0, 0, 0, 0, 0, 0, 0, 0);
+
+        ++count;
+        functionId = CL_FUNCTION_clEnqueueFillImage;
+        clEnqueueFillImage(0, 0, 0, 0, 0, 0, 0, 0);
+
+        ++count;
+        functionId = CL_FUNCTION_clEnqueueMapBuffer;
+        clEnqueueMapBuffer(0, 0, 0, 0, 0, 0, 0, 0, 0, 0);
+
+        ++count;
+        functionId = CL_FUNCTION_clEnqueueMapImage;
+        clEnqueueMapImage(0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0);
+
+        ++count;
+        functionId = CL_FUNCTION_clEnqueueMarker;
+        clEnqueueMarker(0, 0);
+
+        ++count;
+        functionId = CL_FUNCTION_clEnqueueMarkerWithWaitList;
+        clEnqueueMarkerWithWaitList(0, 0, 0, 0);
+
+        ++count;
+        functionId = CL_FUNCTION_clEnqueueMigrateMemObjects;
+        clEnqueueMigrateMemObjects(0, 0, 0, 0, 0, 0, 0);
+
+        ++count;
+        functionId = CL_FUNCTION_clEnqueueNDRangeKernel;
+        clEnqueueNDRangeKernel(0, 0, 0, 0, 0, 0, 0, 0, 0);
+
+        ++count;
+        functionId = CL_FUNCTION_clEnqueueNativeKernel;
+        clEnqueueNativeKernel(0, 0, 0, 0, 0, 0, 0, 0, 0, 0);
+
+        ++count;
+        functionId = CL_FUNCTION_clEnqueueReadBuffer;
+        clEnqueueReadBuffer(0, 0, 0, 0, 0, 0, 0, 0, 0);
+
+        ++count;
+        functionId = CL_FUNCTION_clEnqueueReadBufferRect;
+        clEnqueueReadBufferRect(0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0);
+
+        ++count;
+        functionId = CL_FUNCTION_clEnqueueReadImage;
+        clEnqueueReadImage(0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0);
+
+        ++count;
+        functionId = CL_FUNCTION_clEnqueueSVMFree;
+        clEnqueueSVMFree(0, 0, 0, 0, 0, 0, 0, 0);
+
+        ++count;
+        functionId = CL_FUNCTION_clEnqueueSVMMap;
+        clEnqueueSVMMap(0, 0, 0, 0, 0, 0, 0, 0);
+
+        ++count;
+        functionId = CL_FUNCTION_clEnqueueSVMMemFill;
+        clEnqueueSVMMemFill(0, 0, 0, 0, 0, 0, 0, 0);
+
+        ++count;
+        functionId = CL_FUNCTION_clEnqueueSVMMemcpy;
+        clEnqueueSVMMemcpy(0, 0, 0, 0, 0, 0, 0, 0);
+
+        ++count;
+        functionId = CL_FUNCTION_clEnqueueSVMMigrateMem;
+        clEnqueueSVMMigrateMem(0, 0, 0, 0, 0, 0, 0, 0);
+
+        ++count;
+        functionId = CL_FUNCTION_clEnqueueSVMUnmap;
+        clEnqueueSVMUnmap(0, 0, 0, 0, 0);
+
+        ++count;
+        functionId = CL_FUNCTION_clEnqueueTask;
+        clEnqueueTask(0, 0, 0, 0, 0);
+
+        ++count;
+        functionId = CL_FUNCTION_clEnqueueUnmapMemObject;
+        clEnqueueUnmapMemObject(0, 0, 0, 0, 0, 0);
+
+        ++count;
+        functionId = CL_FUNCTION_clEnqueueWaitForEvents;
+        clEnqueueWaitForEvents(0, 0, 0);
+
+        ++count;
+        functionId = CL_FUNCTION_clEnqueueWriteBuffer;
+        clEnqueueWriteBuffer(0, 0, 0, 0, 0, 0, 0, 0, 0);
+
+        ++count;
+        functionId = CL_FUNCTION_clEnqueueWriteBufferRect;
+        clEnqueueWriteBufferRect(0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0);
+
+        ++count;
+        functionId = CL_FUNCTION_clEnqueueWriteImage;
+        clEnqueueWriteImage(0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0);
+
+        ++count;
+        functionId = CL_FUNCTION_clFinish;
+        clFinish(0);
+
+        ++count;
+        functionId = CL_FUNCTION_clFlush;
+        clFlush(0);
+
+        ++count;
+        functionId = CL_FUNCTION_clGetCommandQueueInfo;
+        clGetCommandQueueInfo(0, 0, 0, 0, 0);
+
+        ++count;
+        functionId = CL_FUNCTION_clGetContextInfo;
+        clGetContextInfo(0, 0, 0, 0, 0);
+
+        ++count;
+        functionId = CL_FUNCTION_clGetDeviceAndHostTimer;
+        clGetDeviceAndHostTimer(0, 0, 0);
+
+        ++count;
+        functionId = CL_FUNCTION_clGetDeviceIDs;
+        clGetDeviceIDs(0, 0, 0, 0, 0);
+
+        ++count;
+        functionId = CL_FUNCTION_clGetDeviceInfo;
+        clGetDeviceInfo(0, 0, 0, 0, 0);
+
+        ++count;
+        functionId = CL_FUNCTION_clGetEventInfo;
+        clGetEventInfo(0, 0, 0, 0, 0);
+
+        ++count;
+        functionId = CL_FUNCTION_clGetEventProfilingInfo;
+        clGetEventProfilingInfo(0, 0, 0, 0, 0);
+
+        ++count;
+        functionId = CL_FUNCTION_clGetExtensionFunctionAddress;
+        clGetExtensionFunctionAddress("test");
+
+        ++count;
+        functionId = CL_FUNCTION_clGetExtensionFunctionAddressForPlatform;
+        clGetExtensionFunctionAddressForPlatform(0, "test");
+
+        ++count;
+        functionId = CL_FUNCTION_clGetHostTimer;
+        clGetHostTimer(0, 0);
+
+        ++count;
+        functionId = CL_FUNCTION_clGetImageInfo;
+        clGetImageInfo(0, 0, 0, 0, 0);
+
+        ++count;
+        functionId = CL_FUNCTION_clGetKernelArgInfo;
+        clGetKernelArgInfo(0, 0, 0, 0, 0, 0);
+
+        ++count;
+        functionId = CL_FUNCTION_clGetKernelInfo;
+        clGetKernelInfo(0, 0, 0, 0, 0);
+
+        ++count;
+        functionId = CL_FUNCTION_clGetKernelSubGroupInfo;
+        clGetKernelSubGroupInfo(0, 0, 0, 0, 0, 0, 0, 0);
+
+        ++count;
+        functionId = CL_FUNCTION_clGetKernelWorkGroupInfo;
+        clGetKernelWorkGroupInfo(0, 0, 0, 0, 0, 0);
+
+        ++count;
+        functionId = CL_FUNCTION_clGetMemObjectInfo;
+        clGetMemObjectInfo(0, 0, 0, 0, 0);
+
+        ++count;
+        functionId = CL_FUNCTION_clGetPipeInfo;
+        clGetPipeInfo(0, 0, 0, 0, 0);
+
+        ++count;
+        functionId = CL_FUNCTION_clGetPlatformIDs;
+        clGetPlatformIDs(0, 0, 0);
+
+        ++count;
+        functionId = CL_FUNCTION_clGetPlatformInfo;
+        clGetPlatformInfo(0, 0, 0, 0, 0);
+
+        ++count;
+        functionId = CL_FUNCTION_clGetProgramBuildInfo;
+        clGetProgramBuildInfo(0, 0, 0, 0, 0, 0);
+
+        ++count;
+        functionId = CL_FUNCTION_clGetProgramInfo;
+        clGetProgramInfo(0, 0, 0, 0, 0);
+
+        ++count;
+        functionId = CL_FUNCTION_clGetSamplerInfo;
+        clGetSamplerInfo(0, 0, 0, 0, 0);
+
+        ++count;
+        functionId = CL_FUNCTION_clGetSupportedImageFormats;
+        clGetSupportedImageFormats(0, 0, 0, 0, 0, 0);
+
+        ++count;
+        functionId = CL_FUNCTION_clLinkProgram;
+        clLinkProgram(0, 0, 0, 0, 0, 0, 0, 0, 0);
+
+        ++count;
+        functionId = CL_FUNCTION_clReleaseCommandQueue;
+        clReleaseCommandQueue(0);
+
+        ++count;
+        functionId = CL_FUNCTION_clReleaseContext;
+        clReleaseContext(0);
+
+        ++count;
+        functionId = CL_FUNCTION_clReleaseDevice;
+        clReleaseDevice(0);
+
+        ++count;
+        functionId = CL_FUNCTION_clReleaseEvent;
+        clReleaseEvent(0);
+
+        ++count;
+        functionId = CL_FUNCTION_clReleaseKernel;
+        clReleaseKernel(0);
+
+        ++count;
+        functionId = CL_FUNCTION_clReleaseMemObject;
+        clReleaseMemObject(0);
+
+        ++count;
+        functionId = CL_FUNCTION_clReleaseProgram;
+        clReleaseProgram(0);
+
+        ++count;
+        functionId = CL_FUNCTION_clReleaseSampler;
+        clReleaseSampler(0);
+
+        ++count;
+        functionId = CL_FUNCTION_clRetainCommandQueue;
+        clRetainCommandQueue(0);
+
+        ++count;
+        functionId = CL_FUNCTION_clRetainContext;
+        clRetainContext(0);
+
+        ++count;
+        functionId = CL_FUNCTION_clRetainDevice;
+        clRetainDevice(0);
+
+        ++count;
+        functionId = CL_FUNCTION_clRetainEvent;
+        clRetainEvent(0);
+
+        ++count;
+        functionId = CL_FUNCTION_clRetainKernel;
+        clRetainKernel(0);
+
+        ++count;
+        functionId = CL_FUNCTION_clRetainMemObject;
+        clRetainMemObject(0);
+
+        ++count;
+        functionId = CL_FUNCTION_clRetainProgram;
+        clRetainProgram(0);
+
+        ++count;
+        functionId = CL_FUNCTION_clRetainSampler;
+        clRetainSampler(0);
+
+        ++count;
+        functionId = CL_FUNCTION_clSVMAlloc;
+        clSVMAlloc(0, 0, 0, 0);
+
+        ++count;
+        functionId = CL_FUNCTION_clSVMFree;
+        clSVMFree(0, 0);
+
+        ++count;
+        functionId = CL_FUNCTION_clSetCommandQueueProperty;
+        clSetCommandQueueProperty(0, 0, 0, 0);
+
+        ++count;
+        functionId = CL_FUNCTION_clSetDefaultDeviceCommandQueue;
+        clSetDefaultDeviceCommandQueue(0, 0, 0);
+
+        ++count;
+        functionId = CL_FUNCTION_clSetEventCallback;
+        clSetEventCallback(0, 0, 0, 0);
+
+        ++count;
+        functionId = CL_FUNCTION_clSetKernelArg;
+        clSetKernelArg(0, 0, 0, 0);
+
+        ++count;
+        functionId = CL_FUNCTION_clSetKernelArgSVMPointer;
+        clSetKernelArgSVMPointer(0, 0, 0);
+
+        ++count;
+        functionId = CL_FUNCTION_clSetKernelExecInfo;
+        clSetKernelExecInfo(0, 0, 0, 0);
+
+        ++count;
+        functionId = CL_FUNCTION_clSetMemObjectDestructorCallback;
+        clSetMemObjectDestructorCallback(0, 0, 0);
+
+        ++count;
+        functionId = CL_FUNCTION_clSetUserEventStatus;
+        clSetUserEventStatus(0, 0);
+
+        ++count;
+        functionId = CL_FUNCTION_clUnloadCompiler;
+        clUnloadCompiler();
+
+        ++count;
+        functionId = CL_FUNCTION_clUnloadPlatformCompiler;
+        clUnloadPlatformCompiler(0);
+
+        ++count;
+        functionId = CL_FUNCTION_clWaitForEvents;
+        clWaitForEvents(0, 0);
+
+        return count;
+    }
+
+  protected:
+    uint16_t enterCount = 0;
+    uint16_t exitCount = 0;
+    cl_function_id functionId = CL_FUNCTION_COUNT;
+};
+
+TEST_F(IntelAllTracingTest, GivenAllFunctionsToTraceExpectPass) {
+    uint16_t count = callFunctions();
+    EXPECT_EQ(count, enterCount);
+    EXPECT_EQ(count, exitCount);
+}
+
+TEST_F(IntelAllTracingTest, GivenNoFunctionsToTraceExpectPass) {
+    for (uint32_t i = 0; i < CL_FUNCTION_COUNT; ++i) {
+        status = clSetTracingPointINTEL(handle, static_cast<cl_function_id>(i), CL_FALSE);
+        EXPECT_EQ(CL_SUCCESS, status);
+    }
+
+    callFunctions();
+
+    EXPECT_EQ(0, enterCount);
+    EXPECT_EQ(0, exitCount);
+}
+
+struct IntelClGetDeviceInfoTracingCollectTest : public IntelAllTracingTest {
+  public:
+    IntelClGetDeviceInfoTracingCollectTest() {}
+
+  protected:
+    void call(cl_device_id target) {
+        device = target;
+        status = clGetDeviceInfo(device, CL_DEVICE_VENDOR, 0, nullptr, &paramValueSizeRet);
+    }
+
+    void vcallback(cl_function_id fid, cl_callback_data *callbackData, void *userData) override {
+        EXPECT_EQ(CL_FUNCTION_clGetDeviceInfo, fid);
+        EXPECT_NE(nullptr, callbackData);
+
+        if (callbackData->site == CL_CALLBACK_SITE_ENTER) {
+            correlationId = callbackData->correlationId;
+            EXPECT_NE(nullptr, callbackData->correlationData);
+            callbackData->correlationData[0] = 777ull;
+        } else {
+            EXPECT_EQ(correlationId, callbackData->correlationId);
+            EXPECT_NE(nullptr, callbackData->correlationData);
+            EXPECT_EQ(777ull, callbackData->correlationData[0]);
+        }
+
+        EXPECT_NE(nullptr, callbackData->functionName);
+        EXPECT_STREQ("clGetDeviceInfo", callbackData->functionName);
+        EXPECT_NE(nullptr, callbackData->functionParams);
+        if (callbackData->site == CL_CALLBACK_SITE_ENTER) {
+            EXPECT_EQ(nullptr, callbackData->functionReturnValue);
+        } else {
+            EXPECT_NE(nullptr, callbackData->functionReturnValue);
+        }
+
+        cl_params_clGetDeviceInfo *params = (cl_params_clGetDeviceInfo *)callbackData->functionParams;
+        EXPECT_NE(nullptr, *params->device);
+        EXPECT_EQ(static_cast<cl_device_info>(CL_DEVICE_VENDOR), *params->paramName);
+        EXPECT_EQ(0u, *params->paramValueSize);
+        EXPECT_EQ(nullptr, *params->paramValue);
+
+        if (callbackData->site == CL_CALLBACK_SITE_EXIT) {
+            cl_int *retVal = (cl_int *)callbackData->functionReturnValue;
+            EXPECT_EQ(CL_SUCCESS, *retVal);
+            EXPECT_LT(0u, **params->paramValueSizeRet);
+        }
+
+        if (callbackData->site == CL_CALLBACK_SITE_ENTER) {
+            ++enterCount;
+        } else if (callbackData->site == CL_CALLBACK_SITE_EXIT) {
+            ++exitCount;
+        }
+    }
+
+  protected:
+    cl_device_id device = nullptr;
+    size_t paramValueSizeRet = 0;
+    uint64_t correlationId = 0;
+};
+
+TEST_F(IntelClGetDeviceInfoTracingCollectTest, GeneralTracingCollectionExpectPass) {
+    call(devices[0]);
+    EXPECT_EQ(CL_SUCCESS, status);
+    EXPECT_LT(0u, paramValueSizeRet);
+
+    EXPECT_EQ(1u, enterCount);
+    EXPECT_EQ(1u, exitCount);
+}
+
+struct IntelClGetDeviceInfoTracingChangeParamsTest : public IntelAllTracingTest {
+  public:
+    IntelClGetDeviceInfoTracingChangeParamsTest() {}
+
+  protected:
+    void call(cl_device_id target) {
+        device = target;
+        status = clGetDeviceInfo(device, CL_DEVICE_VENDOR, 0, nullptr, &paramValueSizeRet);
+    }
+
+    void vcallback(cl_function_id fid, cl_callback_data *callbackData, void *userData) override {
+        if (callbackData->site == CL_CALLBACK_SITE_ENTER) {
+            cl_params_clGetDeviceInfo *params = (cl_params_clGetDeviceInfo *)callbackData->functionParams;
+            *params->paramValueSize = paramValueSize;
+            *params->paramValue = paramValue;
+        }
+    }
+
+  protected:
+    cl_device_id device = nullptr;
+    size_t paramValueSizeRet = 0;
+    static const size_t paramValueSize = 256;
+    char paramValue[paramValueSize];
+};
+
+TEST_F(IntelClGetDeviceInfoTracingChangeParamsTest, GeneralTracingWithParamsChangeExpectPass) {
+    paramValue[0] = '\0';
+    call(devices[0]);
+    EXPECT_EQ(CL_SUCCESS, status);
+    EXPECT_LT(0u, paramValueSizeRet);
+    EXPECT_STRNE("", paramValue);
+}
+
+struct IntelClGetDeviceInfoTracingChangeRetValTest : public IntelAllTracingTest {
+  public:
+    IntelClGetDeviceInfoTracingChangeRetValTest() {}
+
+  protected:
+    void call(cl_device_id target) {
+        device = target;
+        status = clGetDeviceInfo(device, CL_DEVICE_VENDOR, 0, nullptr, &paramValueSizeRet);
+    }
+
+    void vcallback(cl_function_id fid, cl_callback_data *callbackData, void *userData) override {
+        if (callbackData->site == CL_CALLBACK_SITE_EXIT) {
+            cl_int *retVal = reinterpret_cast<cl_int *>(callbackData->functionReturnValue);
+            *retVal = CL_INVALID_VALUE;
+        }
+    }
+
+  protected:
+    cl_device_id device = nullptr;
+    size_t paramValueSizeRet = 0;
+};
+
+TEST_F(IntelClGetDeviceInfoTracingChangeRetValTest, GeneralTracingWithRetValChangeExpectPass) {
+    call(devices[0]);
+    EXPECT_EQ(CL_INVALID_VALUE, status);
+    EXPECT_LT(0u, paramValueSizeRet);
+}
+
+struct IntelClGetDeviceInfoTwoHandlesTracingCollectTest : public IntelClGetDeviceInfoTracingCollectTest {
+  public:
+    IntelClGetDeviceInfoTwoHandlesTracingCollectTest() {}
+
+    void SetUp() override {
+        IntelClGetDeviceInfoTracingCollectTest::SetUp();
+
+        status = clCreateTracingHandleINTEL(devices[0], callback, this, &secondHandle);
+        ASSERT_NE(nullptr, secondHandle);
+        ASSERT_EQ(CL_SUCCESS, status);
+
+        status = clSetTracingPointINTEL(secondHandle, CL_FUNCTION_clGetDeviceInfo, CL_TRUE);
+        ASSERT_EQ(CL_SUCCESS, status);
+
+        status = clEnableTracingINTEL(secondHandle);
+        ASSERT_EQ(CL_SUCCESS, status);
+    }
+
+    void TearDown() override {
+        status = clDisableTracingINTEL(secondHandle);
+        ASSERT_EQ(CL_SUCCESS, status);
+
+        status = clDestroyTracingHandleINTEL(secondHandle);
+        ASSERT_EQ(CL_SUCCESS, status);
+
+        IntelClGetDeviceInfoTracingCollectTest::TearDown();
+    }
+
+  protected:
+    cl_tracing_handle secondHandle = nullptr;
+};
+
+TEST_F(IntelClGetDeviceInfoTwoHandlesTracingCollectTest, GeneralTracingCollectionWithTwoHandlesExpectPass) {
+    call(devices[0]);
+    EXPECT_EQ(CL_SUCCESS, status);
+    EXPECT_LT(0u, paramValueSizeRet);
+
+    EXPECT_EQ(2u, enterCount);
+    EXPECT_EQ(2u, exitCount);
+}
+
+} // namespace ULT

unit_tests/api/cl_intel_tracing_tests_mt.cpp

@@ -0,0 +1,122 @@
+/*
+ * Copyright (C) 2019 Intel Corporation
+ *
+ * SPDX-License-Identifier: MIT
+ *
+ */
+
+#include "runtime/tracing/tracing_api.h"
+#include "runtime/tracing/tracing_notify.h"
+#include "unit_tests/api/cl_api_tests.h"
+
+using namespace NEO;
+
+namespace ULT {
+
+struct IntelTracingMtTest : public api_tests {
+  public:
+    IntelTracingMtTest() : started(false), count(0) {}
+
+    void SetUp() override {
+        api_tests::SetUp();
+    }
+
+    void TearDown() override {
+        api_tests::TearDown();
+    }
+
+  protected:
+    static void threadBody(int iterationCount, IntelTracingMtTest *test) {
+        test->vthreadBody(iterationCount);
+    }
+
+    virtual void vthreadBody(int iterationCount) {
+        cl_int status = CL_SUCCESS;
+        cl_platform_id platform = nullptr;
+        const uint32_t maxStrSize = 1024;
+        char buffer[maxStrSize] = {0};
+
+        while (!started) {
+        }
+
+        for (int i = 0; i < iterationCount; ++i) {
+            HostSideTracing::AtomicBackoff backoff;
+
+            status = clGetDeviceInfo(devices[0], CL_DEVICE_NAME, maxStrSize, buffer, nullptr);
+            EXPECT_EQ(CL_SUCCESS, status);
+            backoff.pause();
+
+            status = clGetDeviceInfo(devices[0], CL_DEVICE_PLATFORM, sizeof(cl_platform_id), &platform, nullptr);
+            EXPECT_EQ(CL_SUCCESS, status);
+            backoff.pause();
+
+            status = clGetPlatformInfo(platform, CL_PLATFORM_VERSION, maxStrSize, buffer, nullptr);
+            EXPECT_EQ(CL_SUCCESS, status);
+            backoff.pause();
+
+            status = clGetPlatformInfo(platform, CL_PLATFORM_NAME, maxStrSize, buffer, nullptr);
+            EXPECT_EQ(CL_SUCCESS, status);
+            backoff.pause();
+        }
+    }
+
+    static void callback(cl_function_id fid, cl_callback_data *callbackData, void *userData) {
+        ASSERT_NE(nullptr, userData);
+        IntelTracingMtTest *base = (IntelTracingMtTest *)userData;
+        base->vcallback(fid, callbackData, nullptr);
+    }
+
+    virtual void vcallback(cl_function_id fid, cl_callback_data *callbackData, void *userData) {
+        if (fid == CL_FUNCTION_clGetDeviceInfo ||
+            fid == CL_FUNCTION_clGetPlatformInfo) {
+            ++count;
+        }
+    }
+
+  protected:
+    cl_tracing_handle handle = nullptr;
+    cl_int status = CL_SUCCESS;
+
+    std::atomic<bool> started;
+    std::atomic<int> count;
+};
+
+TEST_F(IntelTracingMtTest, SafeTracingFromMultipleThreads) {
+    status = clCreateTracingHandleINTEL(devices[0], callback, this, &handle);
+    EXPECT_EQ(CL_SUCCESS, status);
+
+    status = clSetTracingPointINTEL(handle, CL_FUNCTION_clGetDeviceInfo, CL_TRUE);
+    EXPECT_EQ(CL_SUCCESS, status);
+
+    status = clSetTracingPointINTEL(handle, CL_FUNCTION_clGetPlatformInfo, CL_TRUE);
+    EXPECT_EQ(CL_SUCCESS, status);
+
+    status = clEnableTracingINTEL(handle);
+    EXPECT_EQ(CL_SUCCESS, status);
+
+    int numThreads = 4;
+    int iterationCount = 1024;
+    std::vector<std::thread> threads;
+
+    for (int i = 0; i < numThreads; ++i) {
+        threads.push_back(std::thread(threadBody, iterationCount, this));
+    }
+
+    started = true;
+
+    for (size_t i = 0; i < threads.size(); ++i) {
+        threads[i].join();
+    }
+
+    status = clDisableTracingINTEL(handle);
+    EXPECT_EQ(CL_SUCCESS, status);
+
+    status = clDestroyTracingHandleINTEL(handle);
+    EXPECT_EQ(CL_SUCCESS, status);
+
+    int callsPerIteration = 4;
+    int callbacksPerCall = 2;
+    EXPECT_EQ(numThreads * iterationCount * callsPerIteration * callbacksPerCall, count);
+}
+
+} // namespace ULT

unit_tests/api/gl/CMakeLists.txt

@@ -1,5 +1,5 @@
 #
-# Copyright (C) 2017-2018 Intel Corporation
+# Copyright (C) 2017-2019 Intel Corporation
 #
 # SPDX-License-Identifier: MIT
 #
@@ -18,6 +18,7 @@ if(WIN32)
     ${CMAKE_CURRENT_SOURCE_DIR}/cl_get_gl_context_info_khr_tests.cpp
     ${CMAKE_CURRENT_SOURCE_DIR}/cl_get_gl_object_info_tests.cpp
     ${CMAKE_CURRENT_SOURCE_DIR}/cl_get_gl_texture_info_tests.cpp
+    ${CMAKE_CURRENT_SOURCE_DIR}/cl_gl_intel_tracing_tests.cpp
   )
   target_sources(igdrcl_tests PRIVATE ${IGDRCL_SRCS_tests_api_gl})
 endif()

unit_tests/api/gl/cl_gl_intel_tracing_tests.cpp

@@ -0,0 +1,132 @@
+/*
+ * Copyright (C) 2019 Intel Corporation
+ *
+ * SPDX-License-Identifier: MIT
+ *
+ */
+
+#include "runtime/tracing/tracing_api.h"
+#include "runtime/tracing/tracing_notify.h"
+#include "unit_tests/api/cl_api_tests.h"
+
+using namespace NEO;
+
+namespace ULT {
+
+struct IntelGlTracingTest : public api_tests {
+  public:
+    IntelGlTracingTest() {}
+
+    void SetUp() override {
+        api_tests::SetUp();
+
+        status = clCreateTracingHandleINTEL(devices[0], callback, this, &handle);
+        ASSERT_NE(nullptr, handle);
+        ASSERT_EQ(CL_SUCCESS, status);
+
+        for (uint32_t i = 0; i < CL_FUNCTION_COUNT; ++i) {
+            status = clSetTracingPointINTEL(handle, static_cast<cl_function_id>(i), CL_TRUE);
+            ASSERT_EQ(CL_SUCCESS, status);
+        }
+
+        status = clEnableTracingINTEL(handle);
+        ASSERT_EQ(CL_SUCCESS, status);
+    }
+
+    void TearDown() override {
+        status = clDisableTracingINTEL(handle);
+        ASSERT_EQ(CL_SUCCESS, status);
+
+        status = clDestroyTracingHandleINTEL(handle);
+        ASSERT_EQ(CL_SUCCESS, status);
+
+        api_tests::TearDown();
+    }
+
+  protected:
+    static void callback(cl_function_id fid, cl_callback_data *callback_data, void *user_data) {
+        ASSERT_NE(nullptr, user_data);
+        IntelGlTracingTest *base = (IntelGlTracingTest *)user_data;
+        base->vcallback(fid, callback_data, nullptr);
+    }
+
+    virtual void vcallback(cl_function_id fid, cl_callback_data *callback_data, void *user_data) {
+        if (fid == functionId) {
+            if (callback_data->site == CL_CALLBACK_SITE_ENTER) {
+                ++enterCount;
+            } else if (callback_data->site == CL_CALLBACK_SITE_EXIT) {
+                ++exitCount;
+            }
+        }
+    }
+
+    uint16_t callFunctions() {
+        uint16_t count = 0;
+
+        ++count;
+        functionId = CL_FUNCTION_clCreateFromGLBuffer;
+        clCreateFromGLBuffer(0, 0, 0, 0);
+
+        ++count;
+        functionId = CL_FUNCTION_clCreateFromGLRenderbuffer;
+        clCreateFromGLRenderbuffer(0, 0, 0, 0);
+
+        ++count;
+        functionId = CL_FUNCTION_clCreateFromGLTexture;
+        clCreateFromGLTexture(0, 0, 0, 0, 0, 0);
+
+        ++count;
+        functionId = CL_FUNCTION_clCreateFromGLTexture2D;
+        clCreateFromGLTexture2D(0, 0, 0, 0, 0, 0);
+
+        ++count;
+        functionId = CL_FUNCTION_clCreateFromGLTexture3D;
+        clCreateFromGLTexture3D(0, 0, 0, 0, 0, 0);
+
+        ++count;
+        functionId = CL_FUNCTION_clEnqueueAcquireGLObjects;
+        clEnqueueAcquireGLObjects(0, 0, 0, 0, 0, 0);
+
+        ++count;
+        functionId = CL_FUNCTION_clEnqueueReleaseGLObjects;
+        clEnqueueReleaseGLObjects(0, 0, 0, 0, 0, 0);
+
+        ++count;
+        functionId = CL_FUNCTION_clGetGLObjectInfo;
+        clGetGLObjectInfo(0, 0, 0);
+
+        ++count;
+        functionId = CL_FUNCTION_clGetGLTextureInfo;
+        clGetGLTextureInfo(0, 0, 0, 0, 0);
+
+        return count;
+    }
+
+  protected:
+    cl_tracing_handle handle = nullptr;
+    cl_int status = CL_SUCCESS;
+
+    uint16_t enterCount = 0;
+    uint16_t exitCount = 0;
+    cl_function_id functionId = CL_FUNCTION_COUNT;
+};
+
+TEST_F(IntelGlTracingTest, GivenAllFunctionsToTraceExpectPass) {
+    uint16_t count = callFunctions();
+    EXPECT_EQ(count, enterCount);
+    EXPECT_EQ(count, exitCount);
+}
+
+TEST_F(IntelGlTracingTest, GivenNoFunctionsToTraceExpectPass) {
+    for (uint32_t i = 0; i < CL_FUNCTION_COUNT; ++i) {
+        status = clSetTracingPointINTEL(handle, static_cast<cl_function_id>(i), CL_FALSE);
+        EXPECT_EQ(CL_SUCCESS, status);
+    }
+
+    callFunctions();
+
+    EXPECT_EQ(0, enterCount);
+    EXPECT_EQ(0, exitCount);
+}
+
+} // namespace ULT